package cn.itcast.mq.listener;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.time.LocalTime;
import java.util.Map;

@Component
public class SpringRabbitListener {

    /**
     * 消费 simple.queue队列的消息
     */
//     @RabbitListener(queues = "simple.queue")
//     public void listenSimpleQueue(String msg) {
//         System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
//     }

/**
* @Description: 要模拟多个消费者绑定同一个队列，我们在consumer服务的SpringRabbitListener中添加2个新的方法：
* @Param:
* @return:
* @Author: 刘欢
* @Date: 2024/2/27
*/
//    @RabbitListener(queues = "work.queue")
//    public void listenWorkQueue1(String msg) throws InterruptedException {
//        System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
//        Thread.sleep(20);
//    }
//    @RabbitListener(queues = "work.queue")
//    public void listenWorkQueue2(String msg) throws InterruptedException {
//        System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
//        Thread.sleep(200);
//    }

/**
* @Description: 在consumer服务的SpringRabbitListener中添加两个方法，作为消费者：  交换机发送的队列
 *              **Fanout**：广播，将消息交给所有绑定到交换机的队列
* @Author: 刘欢
* @Date: 2024/2/27
*/

//    @RabbitListener(queues = "fanout.queue1")
//    public void listenFanoutQueue1(String msg) {
//        System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
//    }
//
//    @RabbitListener(queues = "fanout.queue2")
//    public void listenFanoutQueue2(String msg) {
//        System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
//    }


    /**
     * 在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。
     * 消息接收
     */
//    @RabbitListener(queues = "direct.queue1")
//    public void listenDirectQueue1(String msg) {
//        System.out.println("消费者1接收到direct.queue1的消息：【" + msg + "】");
//    }
//
//    @RabbitListener(queues = "direct.queue2")
//    public void listenDirectQueue2(String msg) {
//        System.out.println("消费者2接收到direct.queue2的消息：【" + msg + "】");
//    }

    /**
     *  `Topic`类型的`Exchange`与`Direct`相比，都是可以根据`RoutingKey`把消息路由到不同的队列。
     * 只不过`Topic`类型`Exchange`可以让队列在绑定`BindingKey` 的时候使用通配符！
     *
     * `BindingKey` 一般都是有一个或多个单词组成，多个单词之间以`.`分割，例如： `item.insert`
     *
     * 通配符规则：
     * - `#`：匹配一个或多个词
     * - `*`：匹配不多不少恰好1个词
     *
     * 举例：
     * - `item.#`：能够匹配`item.spu.insert` 或者 `item.spu`
     * - `item.*`：只能匹配`item.spu`
     */

//    @RabbitListener(queues = "topic.queue1")
//    public void listenTopicQueue1(String msg){
//        System.out.println("消费者1接收到topic.queue1的消息：【" + msg + "】");
//    }
//
//    @RabbitListener(queues = "topic.queue2")
//    public void listenTopicQueue2(String msg){
//        System.out.println("消费者2接收到topic.queue2的消息：【" + msg + "】");
//    }



    /**
     * 基于注解方式来声明 Direct模式的交换机和队列
     * **Direct**：订阅，基于RoutingKey（路由key）发送给订阅了消息的队列
     */
//    @RabbitListener(bindings = @QueueBinding(
//            value = @Queue(name = "direct.queue1"),
//            exchange = @Exchange(name = "huan1.direct", type = ExchangeTypes.DIRECT),
//            key = {"red", "blue"}
//    ))
//    public void listenDirectQueue1(String msg){
//        System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
//    }
////
//    @RabbitListener(bindings = @QueueBinding(
//            value = @Queue(name = "direct.queue2"),
//            exchange = @Exchange(name = "huan1.direct", type = ExchangeTypes.DIRECT),
//            key = {"red", "yellow"}))
//    public void listenDirectQueue2(String msg){
//        System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
//    }

    /**
     *  Topic模式
     *  **Topic**：通配符订阅，与Direct类似，只不过RoutingKey可以使用通配符
     */
//    @RabbitListener(bindings = @QueueBinding(
//            value = @Queue(name = "topic.queue1"),
//            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
//            key = "china.#"))
//    public void listenTopicQueueTopic1(String msg){
//        System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
//    }
////
//    @RabbitListener(bindings = @QueueBinding(
//            value = @Queue(name = "topic.queue2"),
//            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
//            key = "#.news"))
//    public void listenTopicQueueTopic2(String msg){
//        System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
//    }
////
//    @RabbitListener(queues = "object.queue")
//    public void listenObjectQueue(Map<String,Object> msg){
//        System.out.println("接收到object.queue的消息：" + msg);
//    }


    /**
     * Map发送  Map接收
     */
    @RabbitListener(queues = "object.queue")
    public void listenSimpleQueueMessage(Map<String, Object> msg) throws InterruptedException {
        System.out.println("消费者接收到object.queue消息：【" + msg + "】");
    }
}
